import 'package:chat_client/repositories/hive_repository.dart';
import 'package:hive/hive.dart';

/// 群聊信息本地储存
class GroupRepository {
  // 单例
  GroupRepository._internal() {
    _init();
  }
  static final GroupRepository _instance = GroupRepository._internal();
  static GroupRepository get instance => _instance;

  // hive 实例
  static final _hive = HiveService.instance;

  late final Box _groupBox;
  late final Box _groupMemberBox;

  // 打开数据库
  Future<void> _init() async {
    if (!Hive.isBoxOpen('groupBox')) {
      _groupBox = await _hive.openBox('groupBox');
    }
    if (!Hive.isBoxOpen('groupMemberBox')) {
      _groupMemberBox = await _hive.openBox('groupMemberBox');
    }
  }

  // 储存群聊信息
  Future<void> createOrUpdateGroup(List groups) async {
    for (var group in groups) {
      // 先存储成员数据
      List<String> memberIds = []; // 用于存储成员的 ID
      for (var member in group['members']) {
        // 存储每个成员到 _groupMemberBox
        String memberId = member['memberId'];
        await _groupMemberBox.put(memberId, member); // 存储成员
        memberIds.add(memberId); // 将成员的 ID 添加到 group 中
      }
      // 将成员 IDs 保存到群组数据中
      group['members'] = memberIds;
      // 存储群组信息
      await _groupBox.put(group['groupId'], group); // 存储群组
    }
  }

  // 获取本地群聊信息（包括群组和成员）
  Future<Map<String, dynamic>?> getGroupWithMembers(String groupId) async {
    // 获取群组数据
    var groupData = await _groupBox.get(groupId);
    if (groupData != null) {
      List<String> memberIds = List<String>.from(groupData['members']);
      List<Map<String, dynamic>> members = [];
      // 获取成员数据
      for (var memberId in memberIds) {
        var memberData = await _groupMemberBox.get(memberId);
        if (memberData != null) {
          members.add(memberData);
        }
      }
      return {'group': groupData, 'members': members};
    }
    return null; // 如果没有找到该群组，返回 null
  }

  // 修改本地群聊数据
  Future<void> updateGroup(
      String groupId, Map<String, dynamic> updatedGroupData) async {
    var group = await _groupBox.get(groupId);
    if (group != null) {
      // 更新群组数据
      await _groupBox.put(groupId, updatedGroupData);
    } else {
      throw Exception("Group not found for update.");
    }
  }

  // 修改群成员信息
  Future<void> updateMember(
      String memberId, Map<String, dynamic> updatedMemberData) async {
    var member = await _groupMemberBox.get(memberId);
    if (member != null) {
      // 更新成员数据
      await _groupMemberBox.put(memberId, updatedMemberData);
    } else {
      throw Exception("Member not found for update.");
    }
  }

  // 获取所有群组信息
  Future<List<Map<String, dynamic>>> getAllGroups() async {
    var groupKeys = _groupBox.keys;
    List<Map<String, dynamic>> allGroups = [];
    for (var key in groupKeys) {
      var groupData = await _groupBox.get(key);
      allGroups.add(groupData);
    }
    return allGroups;
  }

  // 删除群组并删除所有群成员
  Future<void> deleteGroup(String groupId) async {
    var group = await _groupBox.get(groupId);
    if (group != null) {
      // 获取群组成员的 IDs
      List<String> memberIds = List<String>.from(group['members']);
      // 删除群成员
      for (var memberId in memberIds) {
        await _groupMemberBox.delete(memberId); // 删除成员
      }
      // 删除群组
      await _groupBox.delete(groupId);
    } else {
      throw Exception("Group not found for deletion.");
    }
  }

  // 删除群成员并更新群聊中的成员列表
  Future<void> deleteMember(String groupId, String memberId) async {
    var groupData = await _groupBox.get(groupId);
    if (groupData != null) {
      // 获取当前群组中的成员 IDs
      List<String> memberIds = List<String>.from(groupData['members']);
      if (memberIds.contains(memberId)) {
        // 从群组成员列表中移除该成员
        memberIds.remove(memberId);
        // 更新群组数据
        groupData['members'] = memberIds;
        await _groupBox.put(groupId, groupData); // 更新群组中的成员列表

        // 删除群成员数据
        await _groupMemberBox.delete(memberId); // 删除成员数据
      } else {
        throw Exception("Member not found in the group.");
      }
    } else {
      throw Exception("Group not found for deletion.");
    }
  }
}
